// SPDX-License-Identifier: GPL-2.0-only
/*
 * Rockchip IO Voltage Domain driver
 *
 * Copyright 2014 MundoReader S.L.
 * Copyright 2014 Google, Inc.
 */

#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/err.h>
#include <linux/mfd/syscon.h>
#include <linux/of.h>
#include <linux/platform_device.h>
#include <linux/regmap.h>
#include <linux/regulator/consumer.h>

#define MAX_SUPPLIES 16

/*
 * The max voltage for 1.8V and 3.3V come from the Rockchip datasheet under
 * "Recommended Operating Conditions" for "Digital GPIO".   When the typical
 * is 3.3V the max is 3.6V.  When the typical is 1.8V the max is 1.98V.
 *
 * They are used like this:
 * - If the voltage on a rail is above the "1.8" voltage (1.98V) we'll tell the
 *   SoC we're at 3.3.
 * - If the voltage on a rail is above the "3.3" voltage (3.6V) we'll consider
 *   that to be an error.
 */
#define MAX_VOLTAGE_1_8 1980000
#define MAX_VOLTAGE_3_3 3600000

#define PX30_IO_VSEL 0x180
#define PX30_IO_VSEL_VCCIO6_SRC BIT(0)
#define PX30_IO_VSEL_VCCIO6_SUPPLY_NUM 1

#define RK3288_SOC_CON2 0x24c
#define RK3288_SOC_CON2_FLASH0 BIT(7)
#define RK3288_SOC_FLASH_SUPPLY_NUM 2

#define RK3328_SOC_CON4 0x410
#define RK3328_SOC_CON4_VCCIO2 BIT(7)
#define RK3328_SOC_VCCIO2_SUPPLY_NUM 1

#define RK3368_SOC_CON15 0x43c
#define RK3368_SOC_CON15_FLASH0 BIT(14)
#define RK3368_SOC_FLASH_SUPPLY_NUM 2

#define RK3399_PMUGRF_CON0 0x180
#define RK3399_PMUGRF_CON0_VSEL BIT(8)
#define RK3399_PMUGRF_VSEL_SUPPLY_NUM 9

#define RK3568_PMU_GRF_IO_VSEL0 (0x0140)
#define RK3568_PMU_GRF_IO_VSEL1 (0x0144)
#define RK3568_PMU_GRF_IO_VSEL2 (0x0148)

struct rockchip_iodomain;

/**
 * @supplies: voltage settings matching the register bits.
 */
struct rockchip_iodomain_soc_data {
    int grf_offset;
    const char *supply_names[MAX_SUPPLIES];
    void (*init)(struct rockchip_iodomain *iod);
};

struct rockchip_iodomain_supply {
    struct rockchip_iodomain *iod;
    struct regulator *reg;
    struct notifier_block nb;
    int idx;
};

struct rockchip_iodomain {
    struct device *dev;
    struct regmap *grf;
    const struct rockchip_iodomain_soc_data *soc_data;
    struct rockchip_iodomain_supply supplies[MAX_SUPPLIES];
    int (*write)(struct rockchip_iodomain_supply *supply, int uV);
};

static int rk3568_pmu_iodomain_write(struct rockchip_iodomain_supply *supply, int uV)
{
    struct rockchip_iodomain *iod = supply->iod;
    u32 is_3v3 = uV > MAX_VOLTAGE_1_8;
    u32 val0, val1;
    int b;

    switch (supply->idx) {
        case 0x0: /* pmuio1 */
            break;
        case 0x1: /* pmuio2 */
            b = supply->idx;
            val0 = BIT(0x10 + b) | (is_3v3 ? 0 : BIT(b));
            b = supply->idx + 0x4;
            val1 = BIT(0x10 + b) | (is_3v3 ? BIT(b) : 0);

            regmap_write(iod->grf, RK3568_PMU_GRF_IO_VSEL2, val0);
            regmap_write(iod->grf, RK3568_PMU_GRF_IO_VSEL2, val1);
            break;
        case 0x3: /* vccio2 */
            break;
        case 0x2: /* vccio1 */
        case 0x4: /* vccio3 */
        case 0x5: /* vccio4 */
        case 0x6: /* vccio5 */
        case 0x7: /* vccio6 */
        case 0x8: /* vccio7 */
            b = supply->idx - 1;
            val0 = BIT(0x10 + b) | (is_3v3 ? 0 : BIT(b));
            val1 = BIT(0x10 + b) | (is_3v3 ? BIT(b) : 0);

            regmap_write(iod->grf, RK3568_PMU_GRF_IO_VSEL0, val0);
            regmap_write(iod->grf, RK3568_PMU_GRF_IO_VSEL1, val1);
            break;
        default:
            return -EINVAL;
    };

    return 0;
}

static int rockchip_iodomain_write(struct rockchip_iodomain_supply *supply, int uV)
{
    struct rockchip_iodomain *iod = supply->iod;
    u32 val;
    int ret;

    /* set value bit */
    val = (uV > MAX_VOLTAGE_1_8) ? 0 : 1;
    val <<= supply->idx;

    /* apply hiword-mask */
    val |= (BIT(supply->idx) << 0x10);

    ret = regmap_write(iod->grf, iod->soc_data->grf_offset, val);
    if (ret) {
        dev_err(iod->dev, "Couldn't write to GRF\n");
    }

    return ret;
}

static int rockchip_iodomain_notify(struct notifier_block *nb, unsigned long event, void *data)
{
    struct rockchip_iodomain_supply *supply = container_of(nb, struct rockchip_iodomain_supply, nb);
    int uV;
    int ret;

    /*
     * According to Rockchip it's important to keep the SoC IO domain
     * higher than (or equal to) the external voltage.  That means we need
     * to change it before external voltage changes happen in the case
     * of an increase.
     *
     * Note that in the "pre" change we pick the max possible voltage that
     * the regulator might end up at (the client requests a range and we
     * don't know for certain the exact voltage).  Right now we rely on the
     * slop in MAX_VOLTAGE_1_8 and MAX_VOLTAGE_3_3 to save us if clients
     * request something like a max of 3.6V when they really want 3.3V.
     * We could attempt to come up with better rules if this fails.
     */
    if (event & REGULATOR_EVENT_PRE_VOLTAGE_CHANGE) {
        struct pre_voltage_change_data *pvc_data = data;

        uV = max_t(unsigned long, pvc_data->old_uV, pvc_data->max_uV);
    } else if (event & (REGULATOR_EVENT_VOLTAGE_CHANGE | REGULATOR_EVENT_ABORT_VOLTAGE_CHANGE)) {
        uV = (unsigned long)data;
    } else {
        return NOTIFY_OK;
    }

    dev_dbg(supply->iod->dev, "Setting to %d\n", uV);

    if (uV > MAX_VOLTAGE_3_3) {
        dev_err(supply->iod->dev, "Voltage too high: %d\n", uV);

        if (event == REGULATOR_EVENT_PRE_VOLTAGE_CHANGE) {
            return NOTIFY_BAD;
        }
    }

    ret = supply->iod->write(supply, uV);
    if (ret && event == REGULATOR_EVENT_PRE_VOLTAGE_CHANGE) {
        return NOTIFY_BAD;
    }

    dev_dbg(supply->iod->dev, "Setting to %d done\n", uV);
    return NOTIFY_OK;
}

static void px30_iodomain_init(struct rockchip_iodomain *iod)
{
    int ret;
    u32 val;

    /* if no VCCIO6 supply we should leave things alone */
    if (!iod->supplies[PX30_IO_VSEL_VCCIO6_SUPPLY_NUM].reg) {
        return;
    }

    /*
     * set vccio6 iodomain to also use this framework
     * instead of a special gpio.
     */
    val = PX30_IO_VSEL_VCCIO6_SRC | (PX30_IO_VSEL_VCCIO6_SRC << 0x10);
    ret = regmap_write(iod->grf, PX30_IO_VSEL, val);
    if (ret < 0) {
        dev_warn(iod->dev, "couldn't update vccio6 ctrl\n");
    }
}

static void rk3288_iodomain_init(struct rockchip_iodomain *iod)
{
    int ret;
    u32 val;

    /* if no flash supply we should leave things alone */
    if (!iod->supplies[RK3288_SOC_FLASH_SUPPLY_NUM].reg) {
        return;
    }

    /*
     * set flash0 iodomain to also use this framework
     * instead of a special gpio.
     */
    val = RK3288_SOC_CON2_FLASH0 | (RK3288_SOC_CON2_FLASH0 << 0x10);
    ret = regmap_write(iod->grf, RK3288_SOC_CON2, val);
    if (ret < 0) {
        dev_warn(iod->dev, "couldn't update flash0 ctrl\n");
    }
}

static void rk3328_iodomain_init(struct rockchip_iodomain *iod)
{
    int ret;
    u32 val;

    /* if no vccio2 supply we should leave things alone */
    if (!iod->supplies[RK3328_SOC_VCCIO2_SUPPLY_NUM].reg) {
        return;
    }

    /*
     * set vccio2 iodomain to also use this framework
     * instead of a special gpio.
     */
    val = RK3328_SOC_CON4_VCCIO2 | (RK3328_SOC_CON4_VCCIO2 << 0x10);
    ret = regmap_write(iod->grf, RK3328_SOC_CON4, val);
    if (ret < 0) {
        dev_warn(iod->dev, "couldn't update vccio2 vsel ctrl\n");
    }
}

static void rk3368_iodomain_init(struct rockchip_iodomain *iod)
{
    int ret;
    u32 val;

    /* if no flash supply we should leave things alone */
    if (!iod->supplies[RK3368_SOC_FLASH_SUPPLY_NUM].reg) {
        return;
    }

    /*
     * set flash0 iodomain to also use this framework
     * instead of a special gpio.
     */
    val = RK3368_SOC_CON15_FLASH0 | (RK3368_SOC_CON15_FLASH0 << 0x10);
    ret = regmap_write(iod->grf, RK3368_SOC_CON15, val);
    if (ret < 0) {
        dev_warn(iod->dev, "couldn't update flash0 ctrl\n");
    }
}

static void rk3399_pmu_iodomain_init(struct rockchip_iodomain *iod)
{
    int ret;
    u32 val;

    /* if no pmu io supply we should leave things alone */
    if (!iod->supplies[RK3399_PMUGRF_VSEL_SUPPLY_NUM].reg) {
        return;
    }

    /*
     * set pmu io iodomain to also use this framework
     * instead of a special gpio.
     */
    val = RK3399_PMUGRF_CON0_VSEL | (RK3399_PMUGRF_CON0_VSEL << 0x10);
    ret = regmap_write(iod->grf, RK3399_PMUGRF_CON0, val);
    if (ret < 0) {
        dev_warn(iod->dev, "couldn't update pmu io iodomain ctrl\n");
    }
}

static const struct rockchip_iodomain_soc_data soc_data_px30 = {
    .grf_offset = 0x180,
    .supply_names =
        {
            NULL,
            "vccio6",
            "vccio1",
            "vccio2",
            "vccio3",
            "vccio4",
            "vccio5",
            "vccio-oscgpi",
        },
    .init = px30_iodomain_init,
};

static const struct rockchip_iodomain_soc_data soc_data_px30_pmu = {
    .grf_offset = 0x100,
    .supply_names =
        {
            NULL,
            NULL,
            NULL,
            NULL,
            NULL,
            NULL,
            NULL,
            NULL,
            NULL,
            NULL,
            NULL,
            NULL,
            NULL,
            NULL,
            "pmuio1",
            "pmuio2",
        },
};

/*
 * On the rk3188 the io-domains are handled by a shared register with the
 * lower 8 bits being still being continuing drive-strength settings.
 */
static const struct rockchip_iodomain_soc_data soc_data_rk3188 = {
    .grf_offset = 0x104,
    .supply_names =
        {
            NULL,
            NULL,
            NULL,
            NULL,
            NULL,
            NULL,
            NULL,
            NULL,
            "ap0",
            "ap1",
            "cif",
            "flash",
            "vccio0",
            "vccio1",
            "lcdc0",
            "lcdc1",
        },
};

static const struct rockchip_iodomain_soc_data soc_data_rk3228 = {
    .grf_offset = 0x418,
    .supply_names =
        {
            "vccio1",
            "vccio2",
            "vccio3",
            "vccio4",
        },
};

static const struct rockchip_iodomain_soc_data soc_data_rk3288 = {
    .grf_offset = 0x380,
    .supply_names =
        {
            "lcdc",     /* LCDC_VDD */
            "dvp",      /* DVPIO_VDD */
            "flash0",   /* FLASH0_VDD (emmc) */
            "flash1",   /* FLASH1_VDD (sdio1) */
            "wifi",     /* APIO3_VDD  (sdio0) */
            "bb",       /* APIO5_VDD */
            "audio",    /* APIO4_VDD */
            "sdcard",   /* SDMMC0_VDD (sdmmc) */
            "gpio30",   /* APIO1_VDD */
            "gpio1830", /* APIO2_VDD */
        },
    .init = rk3288_iodomain_init,
};

static const struct rockchip_iodomain_soc_data soc_data_rk3328 = {
    .grf_offset = 0x410,
    .supply_names =
        {
            "vccio1",
            "vccio2",
            "vccio3",
            "vccio4",
            "vccio5",
            "vccio6",
            "pmuio",
        },
    .init = rk3328_iodomain_init,
};

static const struct rockchip_iodomain_soc_data soc_data_rk3368 = {
    .grf_offset = 0x900,
    .supply_names =
        {
            NULL,          /* reserved */
            "dvp",         /* DVPIO_VDD */
            "flash0",      /* FLASH0_VDD (emmc) */
            "wifi",        /* APIO2_VDD (sdio0) */
            NULL, "audio", /* APIO3_VDD */
            "sdcard",      /* SDMMC0_VDD (sdmmc) */
            "gpio30",      /* APIO1_VDD */
            "gpio1830",    /* APIO4_VDD (gpujtag) */
        },
    .init = rk3368_iodomain_init,
};

static const struct rockchip_iodomain_soc_data soc_data_rk3368_pmu = {
    .grf_offset = 0x100,
    .supply_names =
        {
            NULL, NULL, NULL, NULL, "pmu", /* PMU IO domain */
            "vop",                         /* LCDC IO domain */
        },
};

static const struct rockchip_iodomain_soc_data soc_data_rk3399 = {
    .grf_offset = 0xe640,
    .supply_names =
        {
            "bt656",    /* APIO2_VDD */
            "audio",    /* APIO5_VDD */
            "sdmmc",    /* SDMMC0_VDD */
            "gpio1830", /* APIO4_VDD */
        },
};

static const struct rockchip_iodomain_soc_data soc_data_rk3399_pmu = {
    .grf_offset = 0x180,
    .supply_names =
        {
            NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, "pmu1830", /* PMUIO2_VDD */
        },
    .init = rk3399_pmu_iodomain_init,
};

static const struct rockchip_iodomain_soc_data soc_data_rk3568_pmu = {
    .grf_offset = 0x140,
    .supply_names =
        {
            "pmuio1",
            "pmuio2",
            "vccio1",
            "vccio2",
            "vccio3",
            "vccio4",
            "vccio5",
            "vccio6",
            "vccio7",
        },
};

static const struct rockchip_iodomain_soc_data soc_data_rv1108 = {
    .grf_offset = 0x404,
    .supply_names =
        {
            NULL,
            NULL,
            NULL,
            NULL,
            NULL,
            NULL,
            NULL,
            NULL,
            NULL,
            NULL,
            NULL,
            "vccio1",
            "vccio2",
            "vccio3",
            "vccio5",
            "vccio6",
        },

};

static const struct rockchip_iodomain_soc_data soc_data_rv1108_pmu = {
    .grf_offset = 0x104,
    .supply_names =
        {
            "pmu",
        },
};

static const struct rockchip_iodomain_soc_data soc_data_rv1126_pmu = {
    .grf_offset = 0x140,
    .supply_names =
        {
            NULL,
            "vccio1",
            "vccio2",
            "vccio3",
            "vccio4",
            "vccio5",
            "vccio6",
            "vccio7",
            "pmuio0",
            "pmuio1",
        },
};

static const struct of_device_id rockchip_iodomain_match[] = {
    {.compatible = "rockchip,px30-io-voltage-domain", .data = (void *)&soc_data_px30},
    {.compatible = "rockchip,px30-pmu-io-voltage-domain", .data = (void *)&soc_data_px30_pmu},
    {.compatible = "rockchip,rk3188-io-voltage-domain", .data = &soc_data_rk3188},
    {.compatible = "rockchip,rk3228-io-voltage-domain", .data = &soc_data_rk3228},
    {.compatible = "rockchip,rk3288-io-voltage-domain", .data = &soc_data_rk3288},
    {.compatible = "rockchip,rk3328-io-voltage-domain", .data = &soc_data_rk3328},
    {.compatible = "rockchip,rk3368-io-voltage-domain", .data = &soc_data_rk3368},
    {.compatible = "rockchip,rk3368-pmu-io-voltage-domain", .data = &soc_data_rk3368_pmu},
    {.compatible = "rockchip,rk3399-io-voltage-domain", .data = &soc_data_rk3399},
    {.compatible = "rockchip,rk3399-pmu-io-voltage-domain", .data = &soc_data_rk3399_pmu},
    {.compatible = "rockchip,rk3568-pmu-io-voltage-domain", .data = &soc_data_rk3568_pmu},
    {.compatible = "rockchip,rv1108-io-voltage-domain", .data = &soc_data_rv1108},
    {.compatible = "rockchip,rv1108-pmu-io-voltage-domain", .data = &soc_data_rv1108_pmu},
    {.compatible = "rockchip,rv1126-pmu-io-voltage-domain", .data = &soc_data_rv1126_pmu},
    {},
};
MODULE_DEVICE_TABLE(of, rockchip_iodomain_match);

static int rockchip_iodomain_probe(struct platform_device *pdev)
{
    struct device_node *np = pdev->dev.of_node;
    const struct of_device_id *match;
    struct rockchip_iodomain *iod;
    struct device *parent;
    int i, ret = 0;

    if (!np) {
        return -ENODEV;
    }

    iod = devm_kzalloc(&pdev->dev, sizeof(*iod), GFP_KERNEL);
    if (!iod) {
        return -ENOMEM;
    }

    iod->dev = &pdev->dev;
    platform_set_drvdata(pdev, iod);

    match = of_match_node(rockchip_iodomain_match, np);
    iod->soc_data = match->data;

    if (match->data == &soc_data_rk3568_pmu) {
        iod->write = rk3568_pmu_iodomain_write;
    } else {
        iod->write = rockchip_iodomain_write;
    }

    parent = pdev->dev.parent;
    if (parent && parent->of_node) {
        iod->grf = syscon_node_to_regmap(parent->of_node);
    } else {
        dev_dbg(&pdev->dev, "falling back to old binding\n");
        iod->grf = syscon_regmap_lookup_by_phandle(np, "rockchip,grf");
    }

    if (IS_ERR(iod->grf)) {
        dev_err(&pdev->dev, "couldn't find grf regmap\n");
        return PTR_ERR(iod->grf);
    }

    for (i = 0; i < MAX_SUPPLIES; i++) {
        const char *supply_name = iod->soc_data->supply_names[i];
        struct rockchip_iodomain_supply *supply = &iod->supplies[i];
        struct regulator *reg;
        int uV;
        if (!supply_name) {
            continue;
        }
        reg = devm_regulator_get_optional(iod->dev, supply_name);
        if (IS_ERR(reg)) {
            ret = PTR_ERR(reg);
            /* If a supply wasn't specified, that's OK */
            if (ret == -ENODEV) {
                continue;
            } else if (ret != -EPROBE_DEFER) {
                dev_err(iod->dev, "couldn't get regulator %s\n", supply_name);
            }
            goto unreg_notify;
        }
        /* set initial correct value */
        uV = regulator_get_voltage(reg);
        /* must be a regulator we can get the voltage of */
        if (uV < 0) {
            dev_err(iod->dev, "Can't determine voltage: %s\n", supply_name);
            ret = uV;
            goto unreg_notify;
        }
        if (uV > MAX_VOLTAGE_3_3) {
            dev_crit(iod->dev, "%d uV is too high. May damage SoC!\n", uV);
            ret = -EINVAL;
            goto unreg_notify;
        }
        /* setup our supply */
        supply->idx = i;
        supply->iod = iod;
        supply->reg = reg;
        supply->nb.notifier_call = rockchip_iodomain_notify;

        ret = iod->write(supply, uV);
        if (ret) {
            supply->reg = NULL;
            goto unreg_notify;
        }

        /* register regulator notifier */
        ret = regulator_register_notifier(reg, &supply->nb);
        if (ret) {
            dev_err(&pdev->dev, "regulator notifier request failed\n");
            supply->reg = NULL;
            goto unreg_notify;
        }
    }

    if (iod->soc_data->init) {
        iod->soc_data->init(iod);
    }

    return 0;

unreg_notify:
    for (i = MAX_SUPPLIES - 1; i >= 0; i--) {
        struct rockchip_iodomain_supply *io_supply = &iod->supplies[i];

        if (io_supply->reg) {
            regulator_unregister_notifier(io_supply->reg, &io_supply->nb);
        }
    }

    return ret;
}

static int rockchip_iodomain_remove(struct platform_device *pdev)
{
    struct rockchip_iodomain *iod = platform_get_drvdata(pdev);
    int i;

    for (i = MAX_SUPPLIES - 1; i >= 0; i--) {
        struct rockchip_iodomain_supply *io_supply = &iod->supplies[i];

        if (io_supply->reg) {
            regulator_unregister_notifier(io_supply->reg, &io_supply->nb);
        }
    }

    return 0;
}

static struct platform_driver rockchip_iodomain_driver = {
    .probe = rockchip_iodomain_probe,
    .remove = rockchip_iodomain_remove,
    .driver =
        {
            .name = "rockchip-iodomain",
            .of_match_table = rockchip_iodomain_match,
        },
};

module_platform_driver(rockchip_iodomain_driver);

MODULE_DESCRIPTION("Rockchip IO-domain driver");
MODULE_AUTHOR("Heiko Stuebner <heiko@sntech.de>");
MODULE_AUTHOR("Doug Anderson <dianders@chromium.org>");
MODULE_LICENSE("GPL v2");
